package com.skyd.core.android.game;

import android.graphics.Color;

/**
 * 表示颜色
 * 
 * @author SkyD
 * 
 */
public class GameColor {
	/**
	 * 初始值为0xFF000000。 功能注释：颜色的整数值
	 */
	private int _IntValue = 0xFF000000;

	/**
	 * 获取IntValue。 功能注释：颜色的整数值
	 * 
	 * @return 当前的int类型的值
	 */
	public int getIntValue() {
		return _IntValue;
	}

	/**
	 * 设置IntValue。 功能注释：颜色的整数值
	 * 
	 * @param value
	 *            要设置的int类型值
	 */
	public void setIntValue(int value) {
		_IntValue = value;
	}

	/**
	 * 设置IntValue为其默认值(0xFF000000)。 功能注释：颜色的整数值
	 */
	public void setIntValueToDefault() {
		setIntValue(0xFF000000);
	}

	/**
	 * 创建副本
	 * 
	 * @return 副本
	 */
	public GameColor getClone() {
		return new GameColor(getIntValue());
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return getClone();
	}

	@Override
	public String toString() {
		return "[A:" + getAlpha() + ",R:" + getRed() + ",G:" + getGreen()
				+ ",B:" + getBlue() + "]";
	}

	/**
	 * 构造函数
	 */
	public GameColor() {

	}

	/**
	 * 构造函数
	 * 
	 * @param color
	 *            初始颜色值
	 */
	public GameColor(int color) {
		setIntValue(color);
	}

	/**
	 * 构造函数
	 * 
	 * @param alpha
	 *            初始不透明度值，该值范围为0-255
	 * @param red
	 *            初始红色值，该值范围为0-255
	 * @param green
	 *            初始绿色值，该值范围为0-255
	 * @param blue
	 *            初始蓝色值，该值范围为0-255
	 */
	public GameColor(int alpha, int red, int green, int blue) {
		resetARGB(alpha, red, green, blue);
	}
	
	/**
	 * 构造函数
	 * 
	 * @param alpha
	 *            初始不透明度值，该值范围为0-255
	 * @param Hue
	 *            初始色相值，该值范围为0-360
	 * @param Saturation
	 *            初始饱和度值，该值范围为0-1
	 * @param Brightness
	 *            初始明度值，该值范围为0-1
	 */
	public GameColor(int alpha, float hue, float saturation,
			float brightness) {
		resetAHSB(alpha, hue, saturation, brightness);
	}

	/**
	 * 重设
	 * 
	 * @param alpha
	 *            不透明度值，该值范围为0-255
	 * @param red
	 *            红色值，该值范围为0-255
	 * @param green
	 *            绿色值，该值范围为0-255
	 * @param blue
	 *            蓝色值，该值范围为0-255
	 */
	public void resetARGB(int alpha, int red, int green, int blue) {
		setAlpha(alpha);
		resetRGB(red, green, blue);
	}

	/**
	 * 重设
	 * 
	 * @param red
	 *            红色值，该值范围为0-255
	 * @param green
	 *            绿色值，该值范围为0-255
	 * @param blue
	 *            蓝色值，该值范围为0-255
	 */
	public void resetRGB(int red, int green, int blue) {
		setRed(red);
		setGreen(green);
		setBlue(blue);
	}

	/**
	 * 重设
	 * 
	 * @param alpha
	 *            不透明度值，该值范围为0-255
	 * @param Hue
	 *            色相值，该值范围为0-360
	 * @param Saturation
	 *            饱和度值，该值范围为0-1
	 * @param Brightness
	 *            明度值，该值范围为0-1
	 */
	public void resetAHSB(int alpha, float hue, float saturation,
			float brightness) {
//		float r = 0, g = 0, b = 0;
//		int i = (int) ((hue / 60) % 6);
//		float f = (hue / 60) - i;
//		float p = brightness * (1 - saturation);
//		float q = brightness * (1 - f * saturation);
//		float t = brightness * (1 - (1 - f) * saturation);
//		switch (i) {
//		case 0:
//			r = brightness;
//			g = t;
//			b = p;
//			break;
//		case 1:
//			r = q;
//			g = brightness;
//			b = p;
//			break;
//		case 2:
//			r = p;
//			g = brightness;
//			b = t;
//			break;
//		case 3:
//			r = p;
//			g = q;
//			b = brightness;
//			break;
//		case 4:
//			r = t;
//			g = p;
//			b = brightness;
//			break;
//		case 5:
//			r = brightness;
//			g = p;
//			b = q;
//			break;
//		default:
//			break;
//		}
//		resetARGB(alpha, (int) (r*255f), (int) (g*255f), (int) (b*255f));
		setIntValue(Color.HSVToColor(alpha, new float[]{hue,saturation,brightness}));
	}

	/**
	 * 重设
	 * 
	 * @param hue
	 *            色相值，该值范围为0-360
	 * @param saturation
	 *            饱和度值，该值范围为0-1
	 * @param brightness
	 *            明度值，该值范围为0-1
	 */
	public void resetHSB(float hue, float saturation, float brightness) {
		resetAHSB(getAlpha(), hue, saturation, brightness);
	}

	/**
	 * 获取不透明度值，该值范围为0-255
	 * 
	 * @return 不透明度值
	 */
	public int getAlpha() {
		return Color.alpha(getIntValue());
	}

	/**
	 * 获取红色值，该值范围为0-255
	 * 
	 * @return 红色值
	 */
	public int getRed() {
		return Color.red(getIntValue());
	}

	/**
	 * 获取绿色值，该值范围为0-255
	 * 
	 * @return 绿色值
	 */
	public int getGreen() {
		return Color.green(getIntValue());
	}

	/**
	 * 获取蓝色值，该值范围为0-255
	 * 
	 * @return 蓝色值
	 */
	public int getBlue() {
		return Color.blue(getIntValue());
	}

	/**
	 * 设置不透明度值，该值范围为0-255，超过将自动修正到范围内
	 * 
	 * @param value
	 *            不透明度值
	 */
	public void setAlpha(int value) {
		int v = fixValue(value, 0, 255);
		v = v << 24;
		setIntValue(getIntValue() & 0x00FFFFFF | v);
	}

	/**
	 * 设置红色值，该值范围为0-255，超过将自动修正到范围内
	 * 
	 * @param value
	 *            红色值
	 */
	public void setRed(int value) {
		int v = fixValue(value, 0, 255);
		v = v << 16;
		setIntValue(getIntValue() & 0xFF00FFFF | v);
	}

	/**
	 * 设置绿色值，该值范围为0-255，超过将自动修正到范围内
	 * 
	 * @param value
	 *            绿色值
	 */
	public void setGreen(int value) {
		int v = fixValue(value, 0, 255);
		v = v << 8;
		setIntValue(getIntValue() & 0xFFFF00FF | v);
	}

	/**
	 * 设置蓝色值，该值范围为0-255，超过将自动修正到范围内
	 * 
	 * @param value
	 *            蓝色值
	 */
	public void setBlue(int value) {
		int v = fixValue(value, 0, 255);
		setIntValue(getIntValue() & 0xFFFFFF00 | v);
	}

	/**
	 * 修正数值到指定范围内
	 * 
	 * @param value
	 *            待修正数值
	 * 
	 * @param min
	 *            最小值
	 * @param max
	 *            最大值
	 * @return 范围内的值
	 */
	private int fixValue(int value, int min, int max) {
		if (value <= min)
			return min;
		if (value >= max)
			return max;
		return value;
	}

	/**
	 * 修正数值到指定范围内
	 * 
	 * @param value
	 *            待修正数值
	 * 
	 * @param min
	 *            最小值
	 * @param max
	 *            最大值
	 * @return 范围内的值
	 */
	private float fixValue(float value, float min, float max) {
		if (value <= min)
			return min;
		if (value >= max)
			return max;
		return value;
	}

	/**
	 * 获取色相（0-360）、饱和度(0-1)、明度(0-1)值数组
	 * 
	 * @return HSB值数组
	 */
	public float[] getHSB() {
//		int rgbR = getRed();
//		int rgbG = getGreen();
//		int rgbB = getBlue();
//
//		int[] rgb = new int[] { rgbR, rgbG, rgbB };
//		Arrays.sort(rgb);
//		int max = rgb[2];
//		int min = rgb[0];
//
//		float hsbB = max / 255.0f;
//		float hsbS = max == 0 ? 0 : (max - min) / (float) max;
//
//		float hsbH = 0;
//		if (max == rgbR && rgbG >= rgbB) {
//			hsbH = (rgbG - rgbB) * 60f / (max - min) + 0;
//		} else if (max == rgbR && rgbG < rgbB) {
//			hsbH = (rgbG - rgbB) * 60f / (max - min) + 360;
//		} else if (max == rgbG) {
//			hsbH = (rgbB - rgbR) * 60f / (max - min) + 120;
//		} else if (max == rgbB) {
//			hsbH = (rgbR - rgbG) * 60f / (max - min) + 240;
//		}
//
//		return new float[] { hsbH, hsbS, hsbB };
		float[] hsv=new float[3];
		Color.RGBToHSV(getRed(), getGreen(), getBlue(), hsv);
		return hsv;
	}

	/**
	 * 获取色相值，该值范围为0-360
	 * 
	 * @return 色相值
	 */
	public float getHue() {
		return getHSB()[0];
	}

	/**
	 * 获取饱和度值，该值范围为0-1
	 * 
	 * @return 饱和度值
	 */
	public float getSaturation() {
		return getHSB()[1];
	}

	/**
	 * 获取明度值，该值范围为0-1
	 * 
	 * @return 明度值
	 */
	public float getBrightness() {
		return getHSB()[2];
	}

	/**
	 * 设置色相值，该值范围为0-360，超过将自动修正到范围内
	 * 
	 * @param value
	 *            色相值
	 */
	public void setHue(float value) {
		float v = fixValue(value, 0, 360);
		float[] hsb = getHSB();
		resetHSB(v, hsb[1], hsb[2]);
	}

	/**
	 * 设置饱和度值，该值范围为0-1，超过将自动修正到范围内
	 * 
	 * @param value
	 *            饱和度值
	 */
	public void setSaturation(float value) {
		float v = fixValue(value, 0, 1);
		float[] hsb = getHSB();
		resetHSB(hsb[0], v, hsb[2]);
	}

	/**
	 * 设置明度值，该值范围为0-1，超过将自动修正到范围内
	 * 
	 * @param value
	 *            明度值
	 */
	public void setBrightness(float value) {
		float v = fixValue(value, 0, 1);
		float[] hsb = getHSB();
		resetHSB(hsb[0], hsb[1], v);
	}
}
